home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / libgobj / draw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  26.7 KB  |  1,715 lines
  1. /*
  2.  * Copyright 1984, 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18. #include "gobj.h"
  19.  
  20. #include <gl.h>
  21. #include <stdio.h>
  22.  
  23. static object_t *curobj;    /* current object */
  24. static long curmode;        /* current mode bits */
  25.  
  26. static int gobj_inited = FALSE;
  27.  
  28.  
  29. drawobj(obj, state)
  30.     object_t *obj;
  31.     long state;
  32. {
  33.     int i;
  34.  
  35.     if (!gobj_inited)
  36.     init_gobj();
  37.  
  38.     curobj = obj;
  39.     curmode = 0x0;
  40.  
  41.     drawnode(&obj->blist[0], state);
  42.  
  43.     modesoff();
  44. }
  45.  
  46.  
  47. init_gobj()
  48. {
  49.     int i;
  50.  
  51.     /*
  52.      *  bind materials
  53.      */
  54.     for (i = 0; i < mcount; i++)
  55.     lmdef(DEFMATERIAL, (short)mlist[i].id, 21, mlist[i].data);
  56.  
  57.     gobj_inited = TRUE;
  58. }
  59.  
  60.  
  61. drawnode(np, state)
  62.     node_t *np;
  63.     long state;
  64. {
  65.     int i, todraw;
  66.  
  67.     if (!(state & np->statebits))
  68.     return;
  69.  
  70.     if (np->statebits & CULL)
  71.     {
  72.     if (cull(&curobj->glist[np->slist[0]]))
  73.         return;
  74.     else
  75.         i = 1;
  76.     }
  77.     else
  78.     i = 0;
  79.  
  80.     setmode(np->modebits);
  81.  
  82.     if (np->tcount)
  83.     {
  84.     pushmatrix();
  85.     dotrans(np->tcount, np->tlist);
  86.     }
  87.  
  88.     if ((np->modebits & M_EIGHTVIEW) != 0) 
  89.     {  
  90.     i = (state & EV_MASK) >> EV_SHIFT;
  91.     todraw = i+1;
  92.     }
  93.     else
  94.     todraw = np->scount;
  95.  
  96.     for (; i < todraw; i++)
  97.     {
  98.     if (np->stlist[i] == BRANCH)
  99.         drawnode(&curobj->blist[np->slist[i]], state);
  100.     else
  101.         switch(curobj->glist[np->slist[i]].type)
  102.         {
  103.         case SSECTION:
  104.             drawssect(&curobj->glist[np->slist[i]]);
  105.             break;
  106.         case FSECTION:
  107.             drawfsect(&curobj->glist[np->slist[i]]);
  108.             break;
  109.         case PSECTION:
  110.             drawpsect(&curobj->glist[np->slist[i]]);
  111.             break;
  112.         case CPV_GEOM:
  113.             lsuspend(TRUE);
  114.             drawcpvgeom(&curobj->glist[np->slist[i]]);
  115.             lsuspend(FALSE);
  116.             break;
  117.         case CPU_GEOM:
  118.             lsuspend(TRUE);
  119.             drawcpugeom(&curobj->glist[np->slist[i]]);
  120.             lsuspend(FALSE);
  121.             break;
  122.         case CSECTION:
  123.             lsuspend(TRUE);
  124.             drawcsect(&curobj->glist[np->slist[i]]);
  125.             lsuspend(FALSE);
  126.             break;
  127.         case LTV_GEOM:
  128.             drawltvgeom(&curobj->glist[np->slist[i]]);
  129.             break;
  130.         case CLS_GEOM:
  131.             lsuspend(TRUE);
  132.             drawclsgeom(&curobj->glist[np->slist[i]]);
  133.             lsuspend(FALSE);
  134.             break;
  135.         case CDV_GEOM:
  136.             lsuspend(TRUE);
  137.             drawcdvgeom(&curobj->glist[np->slist[i]]);
  138.             lsuspend(FALSE);
  139.             break;
  140.         case CDU_GEOM:
  141.             lsuspend(TRUE);
  142.             drawcdugeom(&curobj->glist[np->slist[i]]);
  143.             lsuspend(FALSE);
  144.             break;
  145.         case CDS_GEOM:
  146.             lsuspend(TRUE);
  147.             drawcdsgeom(&curobj->glist[np->slist[i]]);
  148.             lsuspend(FALSE);
  149.             break;
  150.         case IMU_GEOM:
  151.             lsuspend(TRUE);
  152.             draw_imu_geom(&curobj->glist[np->slist[i]]);
  153.             lsuspend(FALSE);
  154.             break;
  155.         case IMV_GEOM:
  156.             lsuspend(TRUE);
  157.             draw_imv_geom(&curobj->glist[np->slist[i]]);
  158.             lsuspend(FALSE);
  159.             break;
  160.         case IPU_GEOM:
  161.             lsuspend(TRUE);
  162.             draw_ipu_geom(&curobj->glist[np->slist[i]]);
  163.             lsuspend(FALSE);
  164.             break;
  165.         case IPV_GEOM:
  166.             lsuspend(TRUE);
  167.             draw_ipv_geom(&curobj->glist[np->slist[i]]);
  168.             lsuspend(FALSE);
  169.             break;
  170.         case TLPU_GEOM:
  171.             if (getgdesc(GD_TEXTURE) > 0)
  172.             draw_tlpu_geom(&curobj->glist[np->slist[i]]);
  173.             else
  174.             drawfsect(&curobj->glist[np->slist[i]]);
  175.             break;
  176.         default:
  177.             fprintf(stderr, 
  178.                 "drawnode: unknown geom type (G%d), state %lx\n",
  179.                 np->slist[i],state);
  180.             break;
  181.         }
  182.     }
  183.  
  184.     if (np->tcount)
  185.     popmatrix();
  186. }
  187.  
  188.  
  189. draw_imu_geom(sect)
  190.     geometry_t *sect;
  191. {
  192.     int i, j, k;
  193.     polygon_t *p;
  194.  
  195.     for (i = 0; i < sect->pcount; i++) 
  196.     {
  197.     p = §->plist[i];
  198.     color(p->color);
  199.     switch(p->type) 
  200.     {
  201.         case 0:
  202.         bgnpoint();
  203.         for (j = 0; j < p->vcount; j++) 
  204.             v3f(p->vlist[j]);
  205.         endpoint();
  206.         break;
  207.         case 1:
  208.         bgnline();
  209.         for (j = 0; j < p->vcount; j++) 
  210.             v3f(p->vlist[j]);
  211.         endline();
  212.         break;
  213.         case 2:
  214.         bgnpolygon();
  215.         for (j = 0; j < p->vcount; j++) 
  216.             v3f(p->vlist[j]);
  217.         endpolygon();
  218.         break;
  219.         case 3:
  220.         bgnclosedline();
  221.         for (j = 0; j < p->vcount; j++) 
  222.             v3f(p->vlist[j]);
  223.         endclosedline();
  224.         break;
  225.         case 4:
  226.         setpattern(3);
  227.         bgnpolygon();
  228.         for (j = 0; j < p->vcount; j++) 
  229.             v3f(p->vlist[j]);
  230.         endpolygon();
  231.         setpattern(0);
  232.         break;
  233.         default:
  234.         fprintf(stderr,"Unkown thing in eight-view node %d %d\n",
  235.             p->type,i);
  236.         break;
  237.     }
  238.     }
  239. }
  240.  
  241.  
  242. draw_imv_geom(sect)
  243.     geometry_t *sect;
  244. {
  245.     int i, j, k;
  246.     polygon_t *p;
  247.  
  248.     for (i = 0; i < sect->pcount; i++) 
  249.     {
  250.     p = §->plist[i];
  251.     switch(p->type) 
  252.     {
  253.         case 0:
  254.         bgnpoint();
  255.         for (j = 0; j < p->vcount; j++) 
  256.         {
  257.             color(sect->clist[p->vnlist[j]]);
  258.             v3f(p->vlist[j]);
  259.         }
  260.         endpoint();
  261.         break;
  262.         case 1:
  263.         bgnline();
  264.         for (j = 0; j < p->vcount; j++) 
  265.         {
  266.             color(sect->clist[p->vnlist[j]]);
  267.             v3f(p->vlist[j]);
  268.         }
  269.         endline();
  270.         break;
  271.         case 2:
  272.         bgnpolygon();
  273.         for (j = 0; j < p->vcount; j++) 
  274.         {
  275.             color(sect->clist[p->vnlist[j]]);
  276.             v3f(p->vlist[j]);
  277.         }
  278.         endpolygon();
  279.         break;
  280.         case 3:
  281.         bgnclosedline();
  282.         for (j = 0; j < p->vcount; j++) 
  283.         {
  284.             color(sect->clist[p->vnlist[j]]);
  285.             v3f(p->vlist[j]);
  286.         }
  287.         endclosedline();
  288.         break;
  289.         case 4:
  290.         setpattern(3);
  291.         bgnpolygon();
  292.         for (j = 0; j < p->vcount; j++) 
  293.         {
  294.             color(sect->clist[p->vnlist[j]]);
  295.             v3f(p->vlist[j]);
  296.         }
  297.         endpolygon();
  298.         setpattern(0);
  299.         break;
  300.         default:
  301.         fprintf(stderr,"Unkown thing in eight-view node %d %d\n",
  302.             p->type,i);
  303.         break;
  304.     }
  305.     }
  306. }
  307.  
  308.  
  309. draw_ipu_geom(sect)
  310.     geometry_t *sect;
  311. {
  312.     int i, j, k;
  313.     polygon_t *p;
  314.  
  315.     for (i = 0; i < sect->pcount; i++) 
  316.     {
  317.     p = §->plist[i];
  318.     color(p->color);
  319.     bgnpolygon();
  320.     for (j = 0; j < p->vcount; j++) 
  321.         v3f(p->vlist[j]);
  322.     endpolygon();
  323.     }
  324. }
  325.  
  326.  
  327. draw_ipv_geom(sect)
  328.     geometry_t *sect;
  329. {
  330.     int i, j, k;
  331.     polygon_t *p;
  332.  
  333.     for (i = 0; i < sect->pcount; i++) 
  334.     {
  335.     p = §->plist[i];
  336.     bgnpolygon();
  337.     for (j = 0; j < p->vcount; j++) 
  338.     {
  339.         color(sect->clist[p->vnlist[j]]);
  340.         v3f(p->vlist[j]);
  341.     }
  342.     endpolygon();
  343.     }
  344. }
  345.  
  346.  
  347. drawssect(sect)
  348.     geometry_t *sect;
  349. {
  350.     int i, j;
  351.     polygon_t *p;
  352.  
  353.     setmaterial(sect->material);
  354.  
  355.     for(i=0; i < sect->pcount; i++)
  356.     {
  357.     p = §->plist[i];
  358.     bgnpolygon();
  359.     /*
  360.     out_vnlist(p->vlist, p->nlist, p->vcount);
  361.     */
  362.     for(j=0; j < p->vcount; j++)
  363.     {
  364.         n3f(p->nlist[j]);
  365.         v3f(p->vlist[j]);
  366.     }
  367.     endpolygon();
  368.     }
  369. }
  370.  
  371.  
  372. drawltvgeom(sect)
  373.     geometry_t *sect;
  374. {
  375.     int i, j;
  376.     polygon_t *p;
  377.  
  378.     setmaterial(sect->material);
  379.  
  380.     for(i=0; i < sect->pcount; i++)
  381.     {
  382.     p = §->plist[i];
  383.     bgntmesh();
  384.     /*
  385.     out_vnlist(p->vlist, p->nlist, p->vcount);
  386.     */
  387.     for(j=0; j < p->vcount; j++)
  388.     {
  389.         n3f(p->nlist[j]);
  390.         v3f(p->vlist[j]);
  391.     }
  392.     endtmesh();
  393.     }
  394. }
  395.  
  396.  
  397. drawfsect(sect)
  398.     geometry_t *sect;
  399. {
  400.     int i, j;
  401.     polygon_t *p;
  402.  
  403.     setmaterial(sect->material);
  404.  
  405.     for(i=0; i < sect->pcount; i++)
  406.     {
  407.     p = §->plist[i];
  408.     bgnpolygon();
  409.     n3f(p->normal);
  410.     /*
  411.     out_vlist(p->vlist, p->vcount);
  412.     */
  413.     for(j=0; j < p->vcount; j++)
  414.     {
  415.         v3f(p->vlist[j]);
  416.     }
  417.     endpolygon();
  418.     }
  419. }
  420.  
  421.  
  422. draw_tlpu_geom(sect)
  423.     geometry_t *sect;
  424. {
  425.     int i, j;
  426.     polygon_t *p;
  427.  
  428.     setmaterial(sect->material);
  429.  
  430.     for(i=0; i < sect->pcount; i++)
  431.     {
  432.     p = §->plist[i];
  433.     bgnpolygon();
  434.     n3f(p->normal);
  435.     for(j=0; j < p->vcount; j++)
  436.     {
  437.         t2f(p->xlist[j]);
  438.         v3f(p->vlist[j]);
  439.     }
  440.     endpolygon();
  441.     }
  442. }
  443.  
  444.  
  445. drawpsect(sect)
  446.     geometry_t *sect;
  447. {
  448.     int i, j;
  449.     polygon_t *p;
  450.  
  451.     setmaterial(sect->material);
  452.  
  453.     n3f(sect->normal);
  454.     for(i=0; i < sect->pcount; i++)
  455.     {
  456.     p = §->plist[i];
  457.     bgnpolygon();
  458.     /*
  459.     out_vlist(p->vlist, p->vcount);
  460.     */
  461.     for(j=0; j < p->vcount; j++)
  462.         v3f(p->vlist[j]);
  463.     endpolygon();
  464.     }
  465. }
  466.  
  467.  
  468. drawcpvgeom(sect)
  469.     geometry_t *sect;
  470. {
  471.     int i, j;
  472.     polygon_t *p;
  473.  
  474.     for(i=0; i < sect->pcount; i++)
  475.     {
  476.     p = §->plist[i];
  477.     bgnpolygon();
  478.     out_vclist(p->vlist, p->clist, p->vcount);
  479.     endpolygon();
  480.     }
  481. }
  482.  
  483.  
  484. drawcpugeom(sect)
  485.     geometry_t *sect;
  486. {
  487.     int i, j;
  488.     polygon_t *p;
  489.  
  490.     for(i=0; i < sect->pcount; i++)
  491.     {
  492.     p = §->plist[i];
  493.     bgnpolygon();
  494.     cpack(p->color);
  495.     /*
  496.     out_vlist(p->vlist, p->vcount);
  497.     */
  498.     for(j=0; j < p->vcount; j++)
  499.     {
  500.         v3f(p->vlist[j]);
  501.     }
  502.     endpolygon();
  503.     }
  504. }
  505.  
  506.  
  507. drawcsect(sect)
  508.     geometry_t *sect;
  509. {
  510.     int i, j;
  511.     polygon_t *p;
  512.  
  513.     cpack(sect->color);
  514.  
  515.     for(i=0; i < sect->pcount; i++)
  516.     {
  517.     p = §->plist[i];
  518.     bgnpolygon();
  519.     for(j=0; j < p->vcount; j++)
  520.         v3f(p->vlist[j]);
  521.     endpolygon();
  522.     }
  523. }
  524.  
  525.  
  526. drawclsgeom(g)
  527.     geometry_t *g;
  528. {
  529.     int i, j;
  530.     polygon_t *p;
  531.  
  532.     cpack(g->color);
  533.  
  534.     for(i=0; i < g->pcount; i++)
  535.     {
  536.     p = &g->plist[i];
  537.     bgnline();
  538.     for(j=0; j < p->vcount; j++)
  539.         v3f(p->vlist[j]);
  540.     endline();
  541.     }
  542. }
  543.  
  544.  
  545. drawcdvgeom(sect)
  546.     geometry_t *sect;
  547. {
  548.     int i, j;
  549.     polygon_t *p;
  550.  
  551.     for(i=0; i < sect->pcount; i++)
  552.     {
  553.     p = §->plist[i];
  554.     bgnpoint();
  555.     out_vclist(p->vlist, p->clist, p->vcount);
  556.     endpoint();
  557.     }
  558. }
  559.  
  560.  
  561. drawcdugeom(sect)
  562.     geometry_t *sect;
  563. {
  564.     int i, j;
  565.     polygon_t *p;
  566.  
  567.     for(i=0; i < sect->pcount; i++)
  568.     {
  569.     p = §->plist[i];
  570.     bgnpoint();
  571.     cpack(p->color);
  572.     /*
  573.     out_vlist(p->vlist, p->vcount);
  574.     */
  575.     for(j=0; j < p->vcount; j++)
  576.     {
  577.         v3f(p->vlist[j]);
  578.     }
  579.     endpoint();
  580.     }
  581. }
  582.  
  583.  
  584. drawcdsgeom(g)
  585.     geometry_t *g;
  586. {
  587.     int i, j;
  588.     polygon_t *p;
  589.  
  590.     cpack(g->color);
  591.  
  592.     for(i=0; i < g->pcount; i++)
  593.     {
  594.     p = &g->plist[i];
  595.     bgnpoint();
  596.     for(j=0; j < p->vcount; j++)
  597.         v3f(p->vlist[j]);
  598.     endpoint();
  599.     }
  600. }
  601.  
  602.  
  603. setmode(mode)
  604.     long mode;
  605. {
  606.     int modeson = mode & (~curmode);
  607.     int modesoff = (~mode) & curmode;
  608.  
  609.     if (modeson & MBACKFACE)
  610.     backface(TRUE);
  611.     else if (modesoff & MBACKFACE)
  612.     backface(FALSE);
  613.  
  614.     if (modeson & MTRANSPERENT)
  615.     blendfunction(BF_SA, BF_MSA);
  616.     else if (modesoff & MTRANSPERENT)
  617.     blendfunction(BF_ONE, BF_ZERO);
  618.  
  619.     if (modeson & MZMASK)
  620.     zwritemask(0x0);
  621.     else if (modesoff & MZMASK)
  622.     zwritemask(0xffffff);
  623.  
  624.     if (modeson & MCMASK)
  625.     wmpack(0x0);
  626.     else if (modesoff & MCMASK)
  627.     wmpack(0xffffffff);
  628.  
  629. #ifdef OLDXXX
  630.     /*
  631.      *  turn on modes that need to go on
  632.      */
  633.     switch(mode & ~curmode)
  634.     {
  635.     case 0x0:
  636.         break;
  637.     case 0x1:
  638.         backface(TRUE);
  639.         break;
  640.     case 0x2:
  641.         blendfunction(BF_SA, BF_MSA);
  642.         break;
  643.     case 0x3:
  644.         backface(TRUE);
  645.         blendfunction(BF_SA, BF_MSA);
  646.         break;
  647.     case 0x4:
  648.         zwritemask(0x0);
  649.         break;
  650.     case 0x5:
  651.         backface(TRUE);
  652.         zwritemask(0x0);
  653.         break;
  654.     case 0x6:
  655.         blendfunction(BF_SA, BF_MSA);
  656.         zwritemask(0x0);
  657.         break;
  658.     case 0x7:
  659.         backface(TRUE);
  660.         blendfunction(BF_SA, BF_MSA);
  661.         zwritemask(0x0);
  662.         break;
  663.     default:
  664.         break;
  665.     }
  666.  
  667.     /*
  668.      *  turn off modes that need to go on
  669.      */
  670.     switch((~mode) & curmode)
  671.     {
  672.     case 0x0:
  673.         break;
  674.     case 0x1:
  675.         backface(FALSE);
  676.         break;
  677.     case 0x2:
  678.         blendfunction(BF_ONE, BF_ZERO);
  679.         break;
  680.     case 0x3:
  681.         backface(FALSE);
  682.         blendfunction(BF_ONE, BF_ZERO);
  683.         break;
  684.     case 0x4:
  685.         zwritemask(0xffffff);
  686.         break;
  687.     case 0x5:
  688.         backface(FALSE);
  689.         zwritemask(0xffffff);
  690.         break;
  691.     case 0x6:
  692.         blendfunction(BF_ONE, BF_ZERO);
  693.         zwritemask(0xffffff);
  694.         break;
  695.     case 0x7:
  696.         backface(FALSE);
  697.         blendfunction(BF_ONE, BF_ZERO);
  698.         zwritemask(0xffffff);
  699.         break;
  700.     default:
  701.         break;
  702.     }
  703. #endif
  704.  
  705.     curmode = mode;
  706. }
  707.  
  708.  
  709. modesoff()
  710. {
  711.     if (curmode & MBACKFACE)
  712.     backface(FALSE);
  713.  
  714.     if (curmode & MTRANSPERENT)
  715.     blendfunction(BF_ONE, BF_ZERO);
  716.  
  717.     if (curmode & MZMASK)
  718.     zwritemask(0xffffff);
  719.  
  720.     if (curmode & MCMASK)
  721.     wmpack(0xffffffff);
  722.  
  723. #ifdef OLDXXX
  724.     /*
  725.      *  turn off modes that need to go on
  726.      */
  727.     switch(curmode)
  728.     {
  729.     case 0x0:
  730.         break;
  731.     case 0x1:
  732.         backface(FALSE);
  733.         break;
  734.     case 0x2:
  735.         blendfunction(BF_ONE, BF_ZERO);
  736.         break;
  737.     case 0x3:
  738.         backface(FALSE);
  739.         blendfunction(BF_ONE, BF_ZERO);
  740.         break;
  741.     case 0x4:
  742.         zwritemask(0xffffff);
  743.         break;
  744.     case 0x5:
  745.         backface(FALSE);
  746.         zwritemask(0xffffff);
  747.         break;
  748.     case 0x6:
  749.         blendfunction(BF_ONE, BF_ZERO);
  750.         zwritemask(0xffffff);
  751.         break;
  752.     case 0x7:
  753.         backface(FALSE);
  754.         blendfunction(BF_ONE, BF_ZERO);
  755.         zwritemask(0xffffff);
  756.         break;
  757.     default:
  758.         break;
  759.     }
  760. #endif
  761. }
  762.  
  763.  
  764. dotrans(tcount, tlist)
  765.     int tcount;
  766.     int *tlist;
  767. {
  768.     trans_t *t;
  769.     int i;
  770.  
  771.     for(i=0; i < tcount; i++)
  772.     {
  773.     t = &curobj->tlist[tlist[i]];
  774.     switch(t->type)
  775.     {
  776.         case ROTX:
  777.         rotate(t->angle, 'x');
  778.         break;
  779.         case ROTY:
  780.         rotate(t->angle, 'y');
  781.         break;
  782.         case ROTZ:
  783.         rotate(t->angle, 'z');
  784.         break;
  785.         case TRANSLATE:
  786.         translate(t->x, t->y, t->z);
  787.         break;
  788.         case SCALE:
  789.         scale(t->x, t->y, t->z);
  790.         break;
  791.         default:
  792.         break;
  793.     }
  794.     }
  795. }
  796.  
  797.  
  798. /*
  799.  *  simple wire frame draw
  800.  */
  801. swdrawobj(obj)
  802.     object_t *obj;
  803. {
  804.     int i;
  805.  
  806.     RGBcolor(255, 0, 0);
  807.  
  808.     for (i=0; i < obj->gcount; i++)
  809.     {
  810.     switch(obj->glist[i].type)
  811.     {
  812.         case SSECTION:
  813.         case FSECTION:
  814.         case PSECTION:
  815.         case CSECTION:
  816.         case CLS_GEOM:
  817.         case IMU_GEOM:
  818.         case IMV_GEOM:
  819.         swdrawsect(&obj->glist[i]);
  820.         break;
  821.         default:
  822.         break;
  823.     }
  824.     }
  825. }
  826.  
  827.  
  828. swdrawsect(sect)
  829.     geometry_t *sect;
  830. {
  831.     int i, j;
  832.     polygon_t *p;
  833.  
  834.     for(i=0; i < sect->pcount; i++)
  835.     {
  836.     p = §->plist[i];
  837.     bgnclosedline();
  838.     for(j=0; j < p->vcount; j++)
  839.     {
  840.         v3f(p->vlist[j]);
  841.     }
  842.     endclosedline();
  843.     }
  844. }
  845.  
  846.  
  847. /*
  848.  *  point draw
  849.  */
  850. pdrawobj(obj)
  851.     object_t *obj;
  852. {
  853.     int i;
  854.  
  855.     RGBcolor(255, 0, 0);
  856.  
  857.     for (i=0; i < obj->gcount; i++)
  858.     {
  859.     switch(obj->glist[i].type)
  860.     {
  861.         case SSECTION:
  862.         case FSECTION:
  863.         case PSECTION:
  864.         case CSECTION:
  865.         case CLS_GEOM:
  866.         pdrawsect(&obj->glist[i]);
  867.         break;
  868.         default:
  869.         break;
  870.     }
  871.     }
  872. }
  873.  
  874.  
  875. pdrawsect(sect)
  876.     geometry_t *sect;
  877. {
  878.     int i;
  879.  
  880.     for(i=0; i < sect->vcount; i++)
  881.     {
  882.     bgnpoint();
  883.     v3f(sect->vlist[i]);
  884.     endpoint();
  885.     }
  886. }
  887.  
  888.  
  889. /*
  890.  *  pick point draw
  891.  */
  892. pickdrawobj(obj)
  893.     object_t *obj;
  894. {
  895.     int i;
  896.  
  897.     RGBcolor(255, 0, 0);
  898.  
  899.     for (i=0; i < obj->gcount; i++)
  900.     {
  901.     loadname(i);
  902.     pushname(-1);
  903.     switch(obj->glist[i].type)
  904.     {
  905.         case SSECTION:
  906.         case FSECTION:
  907.         case PSECTION:
  908.         case CSECTION:
  909.         case CLS_GEOM:
  910.         pickdrawsect(&obj->glist[i]);
  911.         break;
  912.         default:
  913.         break;
  914.     }
  915.     popname();
  916.     }
  917. }
  918.  
  919.  
  920. pickdrawsect(sect)
  921.     geometry_t *sect;
  922. {
  923.     int i;
  924.  
  925.     for(i=0; i < sect->vcount; i++)
  926.     {
  927.     loadname(i);
  928.     bgnpoint();
  929.     v3f(sect->vlist[i]);
  930.     endpoint();
  931.     }
  932. }
  933.  
  934.  
  935. tpickdrawobj(obj, state)
  936.     object_t *obj;
  937.     long state;
  938. {
  939.     int i;
  940.  
  941.     curobj = obj;
  942.     curmode = 0x0;
  943.  
  944.     tpickdrawnode(&obj->blist[0], state);
  945. }
  946.  
  947.  
  948. tpickdrawnode(np, state)
  949.     node_t *np;
  950.     long state;
  951. {
  952.     int i;
  953.  
  954.     if (!(state & np->statebits))
  955.     return;
  956.  
  957.     if (np->statebits & CULL)
  958.     {
  959.     if (cull(&curobj->glist[np->slist[0]]))
  960.         return;
  961.     else
  962.         i = 1;
  963.     }
  964.     else
  965.     i = 0;
  966.  
  967.     if (np->tcount)
  968.     {
  969.     pushmatrix();
  970.     dotrans(np->tcount, np->tlist);
  971.     }
  972.  
  973.     for (; i < np->scount; i++)
  974.     {
  975.     if (np->stlist[i] == BRANCH)
  976.         tpickdrawnode(&curobj->blist[np->slist[i]], state);
  977.     else
  978.         switch(curobj->glist[np->slist[i]].type)
  979.         {
  980.         case SSECTION:
  981.         case FSECTION:
  982.         case PSECTION:
  983.         case CSECTION:
  984.         case CLS_GEOM:
  985.             loadname(np->slist[i]);
  986.             pushname(-1);
  987.             pickdrawsect(&curobj->glist[np->slist[i]]);
  988.             popname();
  989.             break;
  990.         default:
  991.             break;
  992.         }
  993.     }
  994.  
  995.     if (np->tcount)
  996.     popmatrix();
  997. }
  998.  
  999.  
  1000. /*
  1001.  *   Solid 2D draw (drop z component)
  1002.  */ 
  1003. s2ddrawobj(obj)
  1004.     object_t *obj;
  1005. {
  1006.     int i;
  1007.  
  1008.     curobj = obj;
  1009.  
  1010.     s2ddrawnode(&obj->blist[0]);
  1011. }
  1012.  
  1013.  
  1014. s2ddrawnode(np)
  1015. node_t *np;
  1016. {
  1017.     int i;
  1018.  
  1019.     if (np->tcount)
  1020.     {
  1021.     pushmatrix();
  1022.     dotrans(np->tcount, np->tlist);
  1023.     }
  1024.  
  1025.     for (i=0; i < np->scount; i++)
  1026.     {
  1027.     if (np->stlist[i] == BRANCH)
  1028.         s2ddrawnode(&curobj->blist[np->slist[i]]);
  1029.     else
  1030.         switch(curobj->glist[np->slist[i]].type)
  1031.         {
  1032.         case IMU_GEOM:
  1033.         case IMV_GEOM:
  1034.             s2ddrawsect(&curobj->glist[i]);
  1035.             break;
  1036.         default:
  1037.             break;
  1038.         }
  1039.     }
  1040.  
  1041.     if (np->tcount)
  1042.     popmatrix();
  1043. }
  1044.  
  1045.  
  1046. s2ddrawsect(sect)
  1047.     geometry_t *sect;
  1048. {
  1049.     int i, j;
  1050.     polygon_t *p;
  1051.  
  1052.     for(i=0; i < sect->pcount; i++)
  1053.     {
  1054.     p = §->plist[i];
  1055.     bgnpolygon();
  1056.     for(j=0; j < p->vcount; j++)
  1057.     {
  1058.         v2f(p->vlist[j]);
  1059.     }
  1060.     endpolygon();
  1061.     }
  1062. }
  1063.  
  1064.  
  1065. /* -------------- wire frame draw --------------- */
  1066.  
  1067. wdrawobj(obj, state)
  1068.     object_t *obj;
  1069.     long state;
  1070. {
  1071.     int i;
  1072.  
  1073.     curobj = obj;
  1074.     curmode = 0x0;
  1075.  
  1076.     wdrawnode(&obj->blist[0], state);
  1077.  
  1078.     modesoff();
  1079. }
  1080.  
  1081.  
  1082. wdrawnode(np, state)
  1083.     node_t *np;
  1084.     long state;
  1085. {
  1086.     int i;
  1087.  
  1088.     if (!(state & np->statebits))
  1089.     return;
  1090.  
  1091.     if (np->statebits & CULL)
  1092.     {
  1093.     if (cull(&curobj->glist[np->slist[0]]))
  1094.         return;
  1095.     else
  1096.         i = 1;
  1097.     }
  1098.     else
  1099.     i = 0;
  1100.  
  1101.     setmode(np->modebits);
  1102.  
  1103.     if (np->tcount)
  1104.     {
  1105.     pushmatrix();
  1106.     dotrans(np->tcount, np->tlist);
  1107.     }
  1108.  
  1109.     for (; i < np->scount; i++)
  1110.     {
  1111.     if (np->stlist[i] == BRANCH)
  1112.         wdrawnode(&curobj->blist[np->slist[i]], state);
  1113.     else
  1114.         switch(curobj->glist[np->slist[i]].type)
  1115.         {
  1116.         case SSECTION:
  1117.             wdrawssect(&curobj->glist[np->slist[i]]);
  1118.             break;
  1119.         case FSECTION:
  1120.             wdrawfsect(&curobj->glist[np->slist[i]]);
  1121.             break;
  1122.         case PSECTION:
  1123.             wdrawpsect(&curobj->glist[np->slist[i]]);
  1124.             break;
  1125.         case CSECTION:
  1126.             wdrawcsect(&curobj->glist[np->slist[i]]);
  1127.             break;
  1128.         case CLS_GEOM:
  1129.             drawclsgeom(&curobj->glist[np->slist[i]]);
  1130.             break;
  1131.         default:
  1132.             break;
  1133.         }
  1134.     }
  1135.  
  1136.     if (np->tcount)
  1137.     popmatrix();
  1138. }
  1139.  
  1140.  
  1141. wdrawssect(sect)
  1142.     geometry_t *sect;
  1143. {
  1144.     int i, j;
  1145.     polygon_t *p;
  1146.  
  1147.     setmaterial(sect->material);
  1148.  
  1149.     for(i=0; i < sect->pcount; i++)
  1150.     {
  1151.     p = §->plist[i];
  1152.     bgnclosedline();
  1153.     for(j=0; j < p->vcount; j++)
  1154.     {
  1155.         n3f(p->nlist[j]);
  1156.         v3f(p->vlist[j]);
  1157.     }
  1158.     endclosedline();
  1159.     }
  1160. }
  1161.  
  1162.  
  1163. wdrawfsect(sect)
  1164.     geometry_t *sect;
  1165. {
  1166.     int i, j;
  1167.     polygon_t *p;
  1168.  
  1169.     setmaterial(sect->material);
  1170.  
  1171.     for(i=0; i < sect->pcount; i++)
  1172.     {
  1173.     p = §->plist[i];
  1174.     bgnclosedline();
  1175.     n3f(p->normal);
  1176.     for(j=0; j < p->vcount; j++)
  1177.     {
  1178.         v3f(p->vlist[j]);
  1179.     }
  1180.     endclosedline();
  1181.     }
  1182. }
  1183.  
  1184.  
  1185. wdrawpsect(sect)
  1186.     geometry_t *sect;
  1187. {
  1188.     int i, j;
  1189.     polygon_t *p;
  1190.  
  1191.     setmaterial(sect->material);
  1192.  
  1193.     n3f(sect->normal);
  1194.     for(i=0; i < sect->pcount; i++)
  1195.     {
  1196.     p = §->plist[i];
  1197.     bgnclosedline();
  1198.     for(j=0; j < p->vcount; j++)
  1199.         v3f(p->vlist[j]);
  1200.     endclosedline();
  1201.     }
  1202. }
  1203.  
  1204.  
  1205. wdrawcsect(sect)
  1206.     geometry_t *sect;
  1207. {
  1208.     int i, j;
  1209.     polygon_t *p;
  1210.  
  1211.     cpack(sect->color);
  1212.  
  1213.     for(i=0; i < sect->pcount; i++)
  1214.     {
  1215.     p = §->plist[i];
  1216.     bgnclosedline();
  1217.     for(j=0; j < p->vcount; j++)
  1218.         v3f(p->vlist[j]);
  1219.     endclosedline();
  1220.     }
  1221. }
  1222.  
  1223.  
  1224. /* -------------- wire frame draw --------------- */
  1225.  
  1226. tswdrawobj(obj, state)
  1227.     object_t *obj;
  1228.     long state;
  1229. {
  1230.     int i;
  1231.  
  1232.     curobj = obj;
  1233.     curmode = 0x0;
  1234.  
  1235.     tswdrawnode(&obj->blist[0], state);
  1236. }
  1237.  
  1238.  
  1239. tswdrawnode(np, state)
  1240.     node_t *np;
  1241.     long state;
  1242. {
  1243.     int i;
  1244.  
  1245.     if (!(state & np->statebits))
  1246.     return;
  1247.  
  1248.     if (np->statebits & CULL)
  1249.     {
  1250.     if (cull(&curobj->glist[np->slist[0]]))
  1251.         return;
  1252.     else
  1253.         i = 1;
  1254.     }
  1255.     else
  1256.     i = 0;
  1257.  
  1258.     if (np->tcount)
  1259.     {
  1260.     pushmatrix();
  1261.     dotrans(np->tcount, np->tlist);
  1262.     }
  1263.  
  1264.     for (; i < np->scount; i++)
  1265.     {
  1266.     if (np->stlist[i] == BRANCH)
  1267.         wdrawnode(&curobj->blist[np->slist[i]], state);
  1268.     else
  1269.         switch(curobj->glist[np->slist[i]].type)
  1270.         {
  1271.         case SSECTION:
  1272.         case FSECTION:
  1273.         case PSECTION:
  1274.         case CSECTION:
  1275.         case CLS_GEOM:
  1276.             swdrawsect(&curobj->glist[np->slist[i]]);
  1277.             break;
  1278.         default:
  1279.             break;
  1280.         }
  1281.     }
  1282.  
  1283.     if (np->tcount)
  1284.     popmatrix();
  1285. }
  1286.  
  1287.  
  1288.  
  1289. /* -------------- misc --------------- */
  1290.  
  1291. cull(g)
  1292.     geometry_t *g;
  1293. {
  1294.     int i, j;
  1295.     polygon_t *p;
  1296.     short fbbuf[10];
  1297.  
  1298.     feedback(fbbuf, 10);
  1299.  
  1300.     for(i=0; i < g->pcount; i++)
  1301.     {
  1302.     p = &g->plist[i];
  1303.     bgnpolygon();
  1304.     for(j=0; j < p->vcount; j++)
  1305.         v3f(p->vlist[j]);
  1306.     endpolygon();
  1307.     }
  1308.  
  1309.     if (endfeedback(fbbuf))
  1310.     return(FALSE);
  1311.     else
  1312.     return(TRUE);
  1313. }
  1314.  
  1315.  
  1316. out_vlist(vlist, count)
  1317.     float **vlist;
  1318.     int count;
  1319. {
  1320.     int i;
  1321.  
  1322.     switch(count)
  1323.     {
  1324.     case 0:
  1325.         break;
  1326.     case 1:
  1327.         v3f(vlist[0]);
  1328.         break;
  1329.     case 2:
  1330.         v3f(vlist[0]);
  1331.         v3f(vlist[1]);
  1332.         break;
  1333.     case 3:
  1334.         v3f(vlist[0]);
  1335.         v3f(vlist[1]);
  1336.         v3f(vlist[2]);
  1337.         break;
  1338.     case 4:
  1339.         v3f(vlist[0]);
  1340.         v3f(vlist[1]);
  1341.         v3f(vlist[2]);
  1342.         v3f(vlist[3]);
  1343.         break;
  1344.     case 5:
  1345.         v3f(vlist[0]);
  1346.         v3f(vlist[1]);
  1347.         v3f(vlist[2]);
  1348.         v3f(vlist[3]);
  1349.         v3f(vlist[4]);
  1350.         break;
  1351.     case 6:
  1352.         v3f(vlist[0]);
  1353.         v3f(vlist[1]);
  1354.         v3f(vlist[2]);
  1355.         v3f(vlist[3]);
  1356.         v3f(vlist[4]);
  1357.         v3f(vlist[5]);
  1358.         break;
  1359.     case 7:
  1360.         v3f(vlist[0]);
  1361.         v3f(vlist[1]);
  1362.         v3f(vlist[2]);
  1363.         v3f(vlist[3]);
  1364.         v3f(vlist[4]);
  1365.         v3f(vlist[5]);
  1366.         v3f(vlist[6]);
  1367.         break;
  1368.     case 8:
  1369.         v3f(vlist[0]);
  1370.         v3f(vlist[1]);
  1371.         v3f(vlist[2]);
  1372.         v3f(vlist[3]);
  1373.         v3f(vlist[4]);
  1374.         v3f(vlist[5]);
  1375.         v3f(vlist[6]);
  1376.         v3f(vlist[7]);
  1377.         break;
  1378.     case 9:
  1379.         v3f(vlist[0]);
  1380.         v3f(vlist[1]);
  1381.         v3f(vlist[2]);
  1382.         v3f(vlist[3]);
  1383.         v3f(vlist[4]);
  1384.         v3f(vlist[5]);
  1385.         v3f(vlist[6]);
  1386.         v3f(vlist[7]);
  1387.         v3f(vlist[8]);
  1388.         break;
  1389.     case 10:
  1390.         v3f(vlist[0]);
  1391.         v3f(vlist[1]);
  1392.         v3f(vlist[2]);
  1393.         v3f(vlist[3]);
  1394.         v3f(vlist[4]);
  1395.         v3f(vlist[5]);
  1396.         v3f(vlist[6]);
  1397.         v3f(vlist[7]);
  1398.         v3f(vlist[8]);
  1399.         v3f(vlist[9]);
  1400.         break;
  1401.     default:
  1402.         for(i=10; i < count; i++)
  1403.         {
  1404.         v3f(vlist[i]);
  1405.         }
  1406.         break;
  1407.     }
  1408. }
  1409.  
  1410.  
  1411. out_vnlist(vlist, nlist, count)
  1412.     float **vlist;
  1413.     float **nlist;
  1414.     int count;
  1415. {
  1416.     int i;
  1417.  
  1418.     switch(count)
  1419.     {
  1420.     case 0:
  1421.         break;
  1422.     case 1:
  1423.         n3f(nlist[0]);
  1424.         v3f(vlist[0]);
  1425.         break;
  1426.     case 2:
  1427.         n3f(nlist[0]);
  1428.         v3f(vlist[0]);
  1429.         n3f(nlist[1]);
  1430.         v3f(vlist[1]);
  1431.         break;
  1432.     case 3:
  1433.         n3f(nlist[0]);
  1434.         v3f(vlist[0]);
  1435.         n3f(nlist[1]);
  1436.         v3f(vlist[1]);
  1437.         n3f(nlist[2]);
  1438.         v3f(vlist[2]);
  1439.         break;
  1440.     case 4:
  1441.         n3f(nlist[0]);
  1442.         v3f(vlist[0]);
  1443.         n3f(nlist[1]);
  1444.         v3f(vlist[1]);
  1445.         n3f(nlist[2]);
  1446.         v3f(vlist[2]);
  1447.         n3f(nlist[3]);
  1448.         v3f(vlist[3]);
  1449.         break;
  1450.     case 5:
  1451.         n3f(nlist[0]);
  1452.         v3f(vlist[0]);
  1453.         n3f(nlist[1]);
  1454.         v3f(vlist[1]);
  1455.         n3f(nlist[2]);
  1456.         v3f(vlist[2]);
  1457.         n3f(nlist[3]);
  1458.         v3f(vlist[3]);
  1459.         n3f(nlist[4]);
  1460.         v3f(vlist[4]);
  1461.         break;
  1462.     case 6:
  1463.         n3f(nlist[0]);
  1464.         v3f(vlist[0]);
  1465.         n3f(nlist[1]);
  1466.         v3f(vlist[1]);
  1467.         n3f(nlist[2]);
  1468.         v3f(vlist[2]);
  1469.         n3f(nlist[3]);
  1470.         v3f(vlist[3]);
  1471.         n3f(nlist[4]);
  1472.         v3f(vlist[4]);
  1473.         n3f(nlist[5]);
  1474.         v3f(vlist[5]);
  1475.         break;
  1476.     case 7:
  1477.         n3f(nlist[0]);
  1478.         v3f(vlist[0]);
  1479.         n3f(nlist[1]);
  1480.         v3f(vlist[1]);
  1481.         n3f(nlist[2]);
  1482.         v3f(vlist[2]);
  1483.         n3f(nlist[3]);
  1484.         v3f(vlist[3]);
  1485.         n3f(nlist[4]);
  1486.         v3f(vlist[4]);
  1487.         n3f(nlist[5]);
  1488.         v3f(vlist[5]);
  1489.         n3f(nlist[6]);
  1490.         v3f(vlist[6]);
  1491.         break;
  1492.     case 8:
  1493.         n3f(nlist[0]);
  1494.         v3f(vlist[0]);
  1495.         n3f(nlist[1]);
  1496.         v3f(vlist[1]);
  1497.         n3f(nlist[2]);
  1498.         v3f(vlist[2]);
  1499.         n3f(nlist[3]);
  1500.         v3f(vlist[3]);
  1501.         n3f(nlist[4]);
  1502.         v3f(vlist[4]);
  1503.         n3f(nlist[5]);
  1504.         v3f(vlist[5]);
  1505.         n3f(nlist[6]);
  1506.         v3f(vlist[6]);
  1507.         n3f(nlist[7]);
  1508.         v3f(vlist[7]);
  1509.         break;
  1510.     case 9:
  1511.         n3f(nlist[0]);
  1512.         v3f(vlist[0]);
  1513.         n3f(nlist[1]);
  1514.         v3f(vlist[1]);
  1515.         n3f(nlist[2]);
  1516.         v3f(vlist[2]);
  1517.         n3f(nlist[3]);
  1518.         v3f(vlist[3]);
  1519.         n3f(nlist[4]);
  1520.         v3f(vlist[4]);
  1521.         n3f(nlist[5]);
  1522.         v3f(vlist[5]);
  1523.         n3f(nlist[6]);
  1524.         v3f(vlist[6]);
  1525.         n3f(nlist[7]);
  1526.         v3f(vlist[7]);
  1527.         n3f(nlist[8]);
  1528.         v3f(vlist[8]);
  1529.         break;
  1530.     case 10:
  1531.         n3f(nlist[0]);
  1532.         v3f(vlist[0]);
  1533.         n3f(nlist[1]);
  1534.         v3f(vlist[1]);
  1535.         n3f(nlist[2]);
  1536.         v3f(vlist[2]);
  1537.         n3f(nlist[3]);
  1538.         v3f(vlist[3]);
  1539.         n3f(nlist[4]);
  1540.         v3f(vlist[4]);
  1541.         n3f(nlist[5]);
  1542.         v3f(vlist[5]);
  1543.         n3f(nlist[6]);
  1544.         v3f(vlist[6]);
  1545.         n3f(nlist[7]);
  1546.         v3f(vlist[7]);
  1547.         n3f(nlist[8]);
  1548.         v3f(vlist[8]);
  1549.         n3f(nlist[9]);
  1550.         v3f(vlist[9]);
  1551.         break;
  1552.     default:
  1553.         for(i=10; i < count; i++)
  1554.         {
  1555.         n3f(nlist[i]);
  1556.         v3f(vlist[i]);
  1557.         }
  1558.         break;
  1559.     }
  1560. }
  1561.  
  1562.  
  1563.  
  1564. out_vclist(vlist, clist, count)
  1565.     float **vlist;
  1566.     long *clist;
  1567.     int count;
  1568. {
  1569.     int i;
  1570.  
  1571.     switch(count)
  1572.     {
  1573.     case 0:
  1574.         break;
  1575.     case 1:
  1576.         cpack(clist[0]);
  1577.         v3f(vlist[0]);
  1578.         break;
  1579.     case 2:
  1580.         cpack(clist[0]);
  1581.         v3f(vlist[0]);
  1582.         cpack(clist[1]);
  1583.         v3f(vlist[1]);
  1584.         break;
  1585.     case 3:
  1586.         cpack(clist[0]);
  1587.         v3f(vlist[0]);
  1588.         cpack(clist[1]);
  1589.         v3f(vlist[1]);
  1590.         cpack(clist[2]);
  1591.         v3f(vlist[2]);
  1592.         break;
  1593.     case 4:
  1594.         cpack(clist[0]);
  1595.         v3f(vlist[0]);
  1596.         cpack(clist[1]);
  1597.         v3f(vlist[1]);
  1598.         cpack(clist[2]);
  1599.         v3f(vlist[2]);
  1600.         cpack(clist[3]);
  1601.         v3f(vlist[3]);
  1602.         break;
  1603.     case 5:
  1604.         cpack(clist[0]);
  1605.         v3f(vlist[0]);
  1606.         cpack(clist[1]);
  1607.         v3f(vlist[1]);
  1608.         cpack(clist[2]);
  1609.         v3f(vlist[2]);
  1610.         cpack(clist[3]);
  1611.         v3f(vlist[3]);
  1612.         cpack(clist[4]);
  1613.         v3f(vlist[4]);
  1614.         break;
  1615.     case 6:
  1616.         cpack(clist[0]);
  1617.         v3f(vlist[0]);
  1618.         cpack(clist[1]);
  1619.         v3f(vlist[1]);
  1620.         cpack(clist[2]);
  1621.         v3f(vlist[2]);
  1622.         cpack(clist[3]);
  1623.         v3f(vlist[3]);
  1624.         cpack(clist[4]);
  1625.         v3f(vlist[4]);
  1626.         cpack(clist[5]);
  1627.         v3f(vlist[5]);
  1628.         break;
  1629.     case 7:
  1630.         cpack(clist[0]);
  1631.         v3f(vlist[0]);
  1632.         cpack(clist[1]);
  1633.         v3f(vlist[1]);
  1634.         cpack(clist[2]);
  1635.         v3f(vlist[2]);
  1636.         cpack(clist[3]);
  1637.         v3f(vlist[3]);
  1638.         cpack(clist[4]);
  1639.         v3f(vlist[4]);
  1640.         cpack(clist[5]);
  1641.         v3f(vlist[5]);
  1642.         cpack(clist[6]);
  1643.         v3f(vlist[6]);
  1644.         break;
  1645.     case 8:
  1646.         cpack(clist[0]);
  1647.         v3f(vlist[0]);
  1648.         cpack(clist[1]);
  1649.         v3f(vlist[1]);
  1650.         cpack(clist[2]);
  1651.         v3f(vlist[2]);
  1652.         cpack(clist[3]);
  1653.         v3f(vlist[3]);
  1654.         cpack(clist[4]);
  1655.         v3f(vlist[4]);
  1656.         cpack(clist[5]);
  1657.         v3f(vlist[5]);
  1658.         cpack(clist[6]);
  1659.         v3f(vlist[6]);
  1660.         cpack(clist[7]);
  1661.         v3f(vlist[7]);
  1662.         break;
  1663.     case 9:
  1664.         cpack(clist[0]);
  1665.         v3f(vlist[0]);
  1666.         cpack(clist[1]);
  1667.         v3f(vlist[1]);
  1668.         cpack(clist[2]);
  1669.         v3f(vlist[2]);
  1670.         cpack(clist[3]);
  1671.         v3f(vlist[3]);
  1672.         cpack(clist[4]);
  1673.         v3f(vlist[4]);
  1674.         cpack(clist[5]);
  1675.         v3f(vlist[5]);
  1676.         cpack(clist[6]);
  1677.         v3f(vlist[6]);
  1678.         cpack(clist[7]);
  1679.         v3f(vlist[7]);
  1680.         cpack(clist[8]);
  1681.         v3f(vlist[8]);
  1682.         break;
  1683.     case 10:
  1684.         cpack(clist[0]);
  1685.         v3f(vlist[0]);
  1686.         cpack(clist[1]);
  1687.         v3f(vlist[1]);
  1688.         cpack(clist[2]);
  1689.         v3f(vlist[2]);
  1690.         cpack(clist[3]);
  1691.         v3f(vlist[3]);
  1692.         cpack(clist[4]);
  1693.         v3f(vlist[4]);
  1694.         cpack(clist[5]);
  1695.         v3f(vlist[5]);
  1696.         cpack(clist[6]);
  1697.         v3f(vlist[6]);
  1698.         cpack(clist[7]);
  1699.         v3f(vlist[7]);
  1700.         cpack(clist[8]);
  1701.         v3f(vlist[8]);
  1702.         cpack(clist[9]);
  1703.         v3f(vlist[9]);
  1704.         break;
  1705.     default:
  1706.         for(i=10; i < count; i++)
  1707.         {
  1708.         cpack(clist[i]);
  1709.         v3f(vlist[i]);
  1710.         }
  1711.         break;
  1712.     }
  1713. }
  1714.  
  1715.